package models

import (
	"time"
	"user_srv/basic/config"
)

// SoulQuestion 灵魂测试题目表
// 用于存储心理测试题目，支持多种题型和难度等级
type SoulQuestion struct {
	Id           uint64    `gorm:"column:id;type:bigint UNSIGNED;primaryKey;not null;autoIncrement;" json:"id"`                                      // 题目ID，主键
	CategoryId   uint64    `gorm:"column:category_id;type:bigint UNSIGNED;index;not null;comment:题目分类ID;" json:"category_id"`                    // 题目分类ID，外键关联SoulQuestionCategory
	QuestionText string    `gorm:"column:question_text;type:text;not null;comment:题目内容;" json:"question_text"`                                   // 题目内容，支持长文本
	QuestionType int8      `gorm:"column:question_type;type:tinyint(1);not null;comment:题目类型 1-单选 2-多选 3-排序 4-量表;" json:"question_type"` // 题目类型：1-单选 2-多选 3-排序 4-量表
	Options      string    `gorm:"column:options;type:json;default:NULL;comment:选项内容;" json:"options"`                                           // 选项内容，JSON格式存储
	Weight       float64   `gorm:"column:weight;type:decimal(3,2);default:1.00;comment:题目权重;" json:"weight"`                                     // 题目权重，用于计算分数
	Difficulty   int8      `gorm:"column:difficulty;type:tinyint(1);default:1;comment:难度 1-简单 2-中等 3-困难;" json:"difficulty"`                 // 难度等级：1-简单 2-中等 3-困难
	SortOrder    int       `gorm:"column:sort_order;type:int;default:0;comment:排序;" json:"sort_order"`                                             // 排序字段，用于控制题目显示顺序
	IsActive     int8      `gorm:"column:is_active;type:tinyint(1);default:1;comment:是否启用;" json:"is_active"`                                    // 是否启用：1-启用 0-禁用
	CreatedAt    time.Time `gorm:"column:created_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"created_at"`                      // 创建时间
	UpdatedAt    time.Time `gorm:"column:updated_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"updated_at"`                      // 更新时间
	DeletedAt    time.Time `gorm:"column:deleted_at;type:datetime(3);default:NULL;" json:"deleted_at"`                                               // 软删除时间
}

// TableName 返回数据库表名
func (SoulQuestion) TableName() string {
	return "soul_question"
}

// Create 创建灵魂测试题目
func (sq *SoulQuestion) Create() error {
	return config.DB.Create(&sq).Error
}

// Update 更新灵魂测试题目
func (sq *SoulQuestion) Update() error {
	return config.DB.Save(sq).Error
}

// SoulQuestionCategory 题目分类表
// 用于对灵魂测试题目进行分类管理，如性格特征、价值观等
type SoulQuestionCategory struct {
	Id          uint64    `gorm:"column:id;type:bigint UNSIGNED;primaryKey;not null;autoIncrement;" json:"id"`                 // 分类ID，主键
	Name        string    `gorm:"column:name;type:varchar(50);not null;comment:分类名称;" json:"name"`                         // 分类名称，如"性格特征"、"价值观"
	Description string    `gorm:"column:description;type:text;default:NULL;comment:分类描述;" json:"description"`              // 分类描述，详细说明该分类的内容
	Weight      float64   `gorm:"column:weight;type:decimal(3,2);default:1.00;comment:分类权重;" json:"weight"`                // 分类权重，用于计算匹配分数
	SortOrder   int       `gorm:"column:sort_order;type:int;default:0;comment:排序;" json:"sort_order"`                        // 排序字段，控制分类显示顺序
	IsActive    int8      `gorm:"column:is_active;type:tinyint(1);default:1;comment:是否启用;" json:"is_active"`               // 是否启用：1-启用 0-禁用
	CreatedAt   time.Time `gorm:"column:created_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"created_at"` // 创建时间
	UpdatedAt   time.Time `gorm:"column:updated_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"updated_at"` // 更新时间
	DeletedAt   time.Time `gorm:"column:deleted_at;type:datetime(3);default:NULL;" json:"deleted_at"`                          // 软删除时间
}

// TableName 返回数据库表名
func (SoulQuestionCategory) TableName() string {
	return "soul_question_category"
}

// GetAll 获取所有启用的题目分类
// 按排序字段升序排列，只返回启用的分类
func (sqc *SoulQuestionCategory) GetAll() ([]SoulQuestionCategory, error) {
	var categories []SoulQuestionCategory
	err := config.DB.Where("is_active = 1").Order("sort_order ASC").Find(&categories).Error
	return categories, err
}

// SoulAnswer 用户答题记录表
// 记录用户对每个题目的答案和分数
type SoulAnswer struct {
	Id            uint64    `gorm:"column:id;type:bigint UNSIGNED;primaryKey;not null;autoIncrement;" json:"id"`                   // 答案ID，主键
	UserId        uint64    `gorm:"column:user_id;type:bigint UNSIGNED;index;not null;comment:用户ID;" json:"user_id"`             // 用户ID，外键关联User表
	QuestionId    uint64    `gorm:"column:question_id;type:bigint UNSIGNED;index;not null;comment:题目ID;" json:"question_id"`     // 题目ID，外键关联SoulQuestion表
	AnswerContent string    `gorm:"column:answer_content;type:json;not null;comment:答案内容;" json:"answer_content"`              // 答案内容，JSON格式存储用户的选择
	AnswerScore   float64   `gorm:"column:answer_score;type:decimal(5,2);default:0;comment:答案分数;" json:"answer_score"`         // 答案分数，用于计算总分
	AnsweredAt    time.Time `gorm:"column:answered_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"answered_at"` // 答题时间
	CreatedAt     time.Time `gorm:"column:created_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"created_at"`   // 创建时间
	UpdatedAt     time.Time `gorm:"column:updated_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"updated_at"`   // 更新时间
	DeletedAt     time.Time `gorm:"column:deleted_at;type:datetime(3);default:NULL;" json:"deleted_at"`                            // 软删除时间
}

// TableName 返回数据库表名
func (SoulAnswer) TableName() string {
	return "soul_answer"
}

// GetByUserId 根据用户ID获取所有答题记录
// 按答题时间降序排列，返回用户的所有答案
func (sa *SoulAnswer) GetByUserId(userId uint64) ([]SoulAnswer, error) {
	var answers []SoulAnswer
	err := config.DB.Where("user_id = ?", userId).Order("answered_at DESC").Find(&answers).Error
	return answers, err
}

// GetByUserAndQuestion 根据用户ID和题目ID获取特定答案
// 用于检查用户是否已回答过某个题目
func (sa *SoulAnswer) GetByUserAndQuestion(userId, questionId uint64) error {
	return config.DB.Where("user_id = ? AND question_id = ?", userId, questionId).First(&sa).Error
}

// Create 创建答案记录
func (sa *SoulAnswer) Create() error {
	return config.DB.Create(&sa).Error
}

// Update 更新答案记录
func (sa *SoulAnswer) Update() error {
	return config.DB.Save(sa).Error
}

// SoulTestResult 用户测试结果表
// 存储用户完成灵魂测试后的综合结果和性格分析
type SoulTestResult struct {
	Id               uint64    `gorm:"column:id;type:bigint UNSIGNED;primaryKey;not null;autoIncrement;" json:"id"`                     // 结果ID，主键
	UserId           uint64    `gorm:"column:user_id;type:bigint UNSIGNED;index;not null;comment:用户ID;" json:"user_id"`               // 用户ID，外键关联User表
	TestVersion      string    `gorm:"column:test_version;type:varchar(20);not null;comment:测试版本;" json:"test_version"`             // 测试版本，用于区分不同版本的测试
	TotalScore       float64   `gorm:"column:total_score;type:decimal(8,2);default:0;comment:总分;" json:"total_score"`                 // 测试总分
	DimensionScores  string    `gorm:"column:dimension_scores;type:json;default:NULL;comment:各维度分数;" json:"dimension_scores"`      // 各维度分数，JSON格式存储
	PersonalityType  string    `gorm:"column:personality_type;type:varchar(50);default:NULL;comment:性格类型;" json:"personality_type"` // 性格类型，如"外向型"、"内向型"
	MatchPreferences string    `gorm:"column:match_preferences;type:json;default:NULL;comment:匹配偏好;" json:"match_preferences"`      // 匹配偏好，JSON格式存储
	TestDuration     int       `gorm:"column:test_duration;type:int;default:0;comment:测试时长(秒);" json:"test_duration"`              // 测试时长，单位秒
	CompletedAt      time.Time `gorm:"column:completed_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"completed_at"` // 完成时间
	CreatedAt        time.Time `gorm:"column:created_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"created_at"`     // 创建时间
	UpdatedAt        time.Time `gorm:"column:updated_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"updated_at"`     // 更新时间
	DeletedAt        time.Time `gorm:"column:deleted_at;type:datetime(3);default:NULL;" json:"deleted_at"`                              // 软删除时间
}

// TableName 返回数据库表名
func (SoulTestResult) TableName() string {
	return "soul_test_result"
}

// GetByUserId 根据用户ID获取最新的测试结果
// 按完成时间降序排列，返回用户最新的测试结果
func (str *SoulTestResult) GetByUserId(userId uint64) error {
	return config.DB.Where("user_id = ?", userId).Order("completed_at DESC").First(&str).Error
}

// Create 创建测试结果记录
func (str *SoulTestResult) Create() error {
	return config.DB.Create(&str).Error
}

// Update 更新测试结果记录
func (str *SoulTestResult) Update() error {
	return config.DB.Save(str).Error
}

// SoulMatchRecord 灵魂匹配记录表
// 记录两个用户之间的灵魂匹配结果和详细信息
type SoulMatchRecord struct {
	Id              uint64    `gorm:"column:id;type:bigint UNSIGNED;primaryKey;not null;autoIncrement;" json:"id"`                           // 匹配记录ID，主键
	User1Id         uint64    `gorm:"column:user1_id;type:bigint UNSIGNED;index;not null;comment:用户1ID;" json:"user1_id"`                  // 用户1ID，外键关联User表
	User2Id         uint64    `gorm:"column:user2_id;type:bigint UNSIGNED;index;not null;comment:用户2ID;" json:"user2_id"`                  // 用户2ID，外键关联User表
	MatchScore      float64   `gorm:"column:match_score;type:decimal(5,2);not null;comment:匹配分数;" json:"match_score"`                    // 匹配分数，0-100分
	MatchReasons    string    `gorm:"column:match_reasons;type:json;default:NULL;comment:匹配原因;" json:"match_reasons"`                    // 匹配原因，JSON格式存储
	DimensionScores string    `gorm:"column:dimension_scores;type:json;default:NULL;comment:各维度匹配分数;" json:"dimension_scores"`        // 各维度匹配分数，JSON格式存储
	MatchType       int8      `gorm:"column:match_type;type:tinyint(1);default:1;comment:匹配类型 1-系统推荐 2-用户主动;" json:"match_type"` // 匹配类型：1-系统推荐 2-用户主动
	Status          int8      `gorm:"column:status;type:tinyint(1);default:1;comment:状态 1-有效 0-无效;" json:"status"`                     // 状态：1-有效 0-无效
	CreatedAt       time.Time `gorm:"column:created_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"created_at"`           // 创建时间
	UpdatedAt       time.Time `gorm:"column:updated_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"updated_at"`           // 更新时间
	DeletedAt       time.Time `gorm:"column:deleted_at;type:datetime(3);default:NULL;" json:"deleted_at"`                                    // 软删除时间
}

// TableName 返回数据库表名
func (SoulMatchRecord) TableName() string {
	return "soul_match_record"
}

// GetByUserId 根据用户ID获取所有匹配记录
// 返回该用户作为user1或user2的所有有效匹配记录，按匹配分数降序排列
func (smr *SoulMatchRecord) GetByUserId(userId uint64) ([]SoulMatchRecord, error) {
	var records []SoulMatchRecord
	err := config.DB.Where("(user1_id = ? OR user2_id = ?) AND status = 1", userId, userId).
		Order("match_score DESC").Find(&records).Error
	return records, err
}

// GetByUserPair 根据两个用户ID获取匹配记录
// 用于检查两个用户之间是否已有匹配记录
func (smr *SoulMatchRecord) GetByUserPair(user1Id, user2Id uint64) error {
	return config.DB.Where("(user1_id = ? AND user2_id = ?) OR (user1_id = ? AND user2_id = ?)", 
		user1Id, user2Id, user2Id, user1Id).First(&smr).Error
}

// Create 创建匹配记录
func (smr *SoulMatchRecord) Create() error {
	return config.DB.Create(&smr).Error
}

// Update 更新匹配记录
func (smr *SoulMatchRecord) Update() error {
	return config.DB.Save(smr).Error
}

// SoulPersonalityDimension 性格维度表
// 定义灵魂匹配中使用的性格维度，如外向性、内向性等
type SoulPersonalityDimension struct {
	Id            uint64    `gorm:"column:id;type:bigint UNSIGNED;primaryKey;not null;autoIncrement;" json:"id"`                    // 维度ID，主键
	DimensionName string    `gorm:"column:dimension_name;type:varchar(50);not null;comment:维度名称;" json:"dimension_name"`        // 维度名称，如"外向性"、"内向性"
	DimensionCode string    `gorm:"column:dimension_code;type:varchar(20);not null;unique;comment:维度代码;" json:"dimension_code"` // 维度代码，如"EXTROVERSION"、"INTROVERSION"
	Description   string    `gorm:"column:description;type:text;default:NULL;comment:维度描述;" json:"description"`                 // 维度描述，详细说明该维度的含义
	Weight        float64   `gorm:"column:weight;type:decimal(3,2);default:1.00;comment:权重;" json:"weight"`                       // 权重，用于计算匹配分数
	SortOrder     int       `gorm:"column:sort_order;type:int;default:0;comment:排序;" json:"sort_order"`                           // 排序字段，控制维度显示顺序
	IsActive      int8      `gorm:"column:is_active;type:tinyint(1);default:1;comment:是否启用;" json:"is_active"`                  // 是否启用：1-启用 0-禁用
	CreatedAt     time.Time `gorm:"column:created_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"created_at"`    // 创建时间
	UpdatedAt     time.Time `gorm:"column:updated_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"updated_at"`    // 更新时间
	DeletedAt     time.Time `gorm:"column:deleted_at;type:datetime(3);default:NULL;" json:"deleted_at"`                             // 软删除时间
}

// TableName 返回数据库表名
func (SoulPersonalityDimension) TableName() string {
	return "soul_personality_dimension"
}

// GetAll 获取所有启用的性格维度
// 按排序字段升序排列，只返回启用的维度
func (spd *SoulPersonalityDimension) GetAll() ([]SoulPersonalityDimension, error) {
	var dimensions []SoulPersonalityDimension
	err := config.DB.Where("is_active = 1").Order("sort_order ASC").Find(&dimensions).Error
	return dimensions, err
}

// Create 创建性格维度
func (spd *SoulPersonalityDimension) Create() error {
	return config.DB.Create(&spd).Error
}

// SoulUserDimensionScore 用户维度分数表
// 记录用户在各个性格维度上的具体分数和百分位数
type SoulUserDimensionScore struct {
	Id          uint64    `gorm:"column:id;type:bigint UNSIGNED;primaryKey;not null;autoIncrement;" json:"id"`                 // 分数ID，主键
	UserId      uint64    `gorm:"column:user_id;type:bigint UNSIGNED;index;not null;comment:用户ID;" json:"user_id"`           // 用户ID，外键关联User表
	DimensionId uint64    `gorm:"column:dimension_id;type:bigint UNSIGNED;index;not null;comment:维度ID;" json:"dimension_id"` // 维度ID，外键关联SoulPersonalityDimension表
	Score       float64   `gorm:"column:score;type:decimal(5,2);not null;comment:分数;" json:"score"`                          // 用户在该维度上的分数
	Percentile  float64   `gorm:"column:percentile;type:decimal(5,2);default:0;comment:百分位数;" json:"percentile"`           // 百分位数，表示用户在该维度上的排名
	UpdatedAt   time.Time `gorm:"column:updated_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"updated_at"` // 更新时间
	CreatedAt   time.Time `gorm:"column:created_at;type:datetime(3);not null;default:CURRENT_TIMESTAMP(3);" json:"created_at"` // 创建时间
}

// TableName 返回数据库表名
func (SoulUserDimensionScore) TableName() string {
	return "soul_user_dimension_score"
}

// GetByUserId 根据用户ID获取所有维度分数
// 返回用户在所有性格维度上的分数记录
func (suds *SoulUserDimensionScore) GetByUserId(userId uint64) ([]SoulUserDimensionScore, error) {
	var scores []SoulUserDimensionScore
	err := config.DB.Where("user_id = ?", userId).Find(&scores).Error
	return scores, err
}

// Create 创建用户维度分数记录
func (suds *SoulUserDimensionScore) Create() error {
	return config.DB.Create(&suds).Error
}

// Update 更新用户维度分数记录
// 用于在用户完成匹配后更新其在每个维度上的分数和百分位数
func (suds *SoulUserDimensionScore) Update() error {
	return config.DB.Save(suds).Error
}
